Registry driven interoperability and exchange of documents

ABSTRACT

The present invention relates to systems and methods for registry driven transformation of a document exchanged between businesses or applications. More particularly, it relates to systems and protocols for using one or more commonly accessible registries to transform electronic commerce documents among dissimilar interfaces, preferably XML documents. Particular aspects of the present invention are described in the claims, specification and drawings.

PRIORITY INFORMATION

This application is a continuation of U.S. application Ser. No.14/183,102, titled “REGISTRY DRIVEN INTEROPERABILITY AND EXCHANGE OFDOCUMENTS”, filed 18 Feb. 2015 (Attorney Docket No. OIN 1025-14), whichis a continuation of U.S. application Ser. No. 12/763,136, titled“REGISTRY DRIVEN INTEROPERABILITY AND EXCHANGE OF DOCUMENTS” filed 19Apr. 2010, which issued as U.S. Pat. No. 8,683,321 on 25 Mar. 2014(Attorney Docket No. OIN 1025-12), which is a continuation of U.S.application Ser. No. 11/369,784, titled “REGISTRY DRIVENINTEROPERABILITY AND EXCHANGE OF DOCUMENTS” filed 7 Mar. 2006, whichissued as U.S. Pat. No. 7,703,008 on 20 Apr. 2010 (Attorney Docket No.OIN 1025-10), which is a divisional of U.S. application Ser. No.10/199,963, titled “REGISTRY DRIVEN INTEROPERABILITY AND EXCHANGE OFDOCUMENT” by Christopher Todd Ingersoll, Jayaram Rajan Kasi, AlexanderHolmes, Michael Clark, Ashok Aletty, Sathish Babu K. Senathi and HelenS. Yeun filed on 19 Jul. 2002, which issued as U.S. Pat. No. 7,047,488on 16 May 2006 (Attorney Docket No. OIN 1025-1).

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains materialthat is subject to copyright protection. The copyright owner has noobjection to the facsimile reproduction by anyone of the patent documentor the patent disclosure as it appears in the Patent and TrademarkOffice patent file or records, but otherwise reserves all copyrightrights whatsoever.

BACKGROUND OF THE INVENTION

The present invention relates to systems and methods for registry drivensemantic transformation of a document exchanged between businesses orapplications. More particularly, it relates to systems and protocols forusing one or more commonly accessible registries to transform electroniccommerce documents among dissimilar interfaces, preferably XMLdocuments.

Business-to-business (B2B) and application-to-application (A2A)electronic commerce are replacing former protocols for electronic datainterchange (EDI). As businesses strive to improve their efficiency withB2B and A2A systems, a number of incompatible platforms and competingstandards have emerged. One need that has been identified is to convertthe documents from one system to another.

XML has become a widely used type of data because the rigid syntacticrules which must be applied to create inline markup make it relativelysimple for computer programs to interpret and process. For example, apurchase order written in XML could be processed by an order entrysoftware application that knows how to read the markup annotations thatdescribe what is being purchased, who the purchaser is, and so forth.The growing acceptance of XML as an encoding scheme for documents hasled to development of XML-ified application program interfaces for manylegacy applications by enterprise adapter implementation (EAI) vendors.

EAI vendors bridge one system to the next, on anapplication-by-application basis. Interoperability is achieved bydesign, at design time. Connections between systems or applications arestatic. Implementation of new versions of applications requiresmodification of the static connections. Routing among applications istypically within an enterprise. Integration logic is developed on apoint-to-point basis. Semantic logic is coded into EAI routines.Semantic logic and syntactic logic are mixed in the coding. The sendingparty or source of a document is responsible to ensure that what theysend is exactly what the target or recipient has advertised to receive.There is no concept of modeling degrees of compatibility for aninterface, as opposed to requiring perfect compatibility. This perfectcompatibility is difficult to achieve, as it requires that all clientsbe updated with the latest versions of the services' interfaces and thatinterfaces be updated contemporaneously. Transformation components aredifficult to reuse. No commonly accessible repository is provided tocapture individual transformation preferences or to supporttransformation based on user profiles. The EAI vendor approach makes itdifficult and costly to adapt transform routines from one pair ofsystems or applications to another.

FIG. 1 illustrates the EAI vendor approach, as applied to supplierprocessing of incoming purchase orders into four disparate systems. Inthis figure, incoming purchase orders originate from three sources 101,an electronic data interchange (EDI) buyer, and online store customerand an Open Application Group Business Object Document (OAGBOD)-compliant buyer. Each of the sources has a native interface 102that produces a purchase order as input to the EAI infrastructure 103.The formats of the documents may include EDI, XML and OAG. Four targetsystems 106, include an SAP Financial system, an SAP MRP system, Biz IQsystem and a Granger shipping system. The native formats of documents105 accepted by these target systems include IDOC, BAPI, OAG and acustom application program interface (API). To connect the source andtarget, both syntactic and semantic differences need to be overcome.Point-to-point adapters 104 transform source documents into targetdocuments on a pairwise basis. Even document transformations betweensystems utilizing the same syntax, such as OAG-to-OAG transformations,involved differing semantics, so an adapter is required. When a sourceor target system is updated, for instance if Oracle financials aresubstituted for SAP financials or an upgraded shipping system isinstalled, new adapters need to be written. In all likelihood, old andnew adapters are both retained by the EAI infrastructure. As systems areupdated, more and more adapters are subject to revision or replacement.A single transformation engine manages the transformation process andprovides the transformation resources.

Accordingly, opportunities arise to devise methods and structures thatcommonly manage transformation of documents between dissimilarinterfaces, that provide runtime interoperability and distributedexecution of transformations.

SUMMARY OF THE INVENTION

The present invention relates to systems and methods for registry driventransformation of a document exchanged between businesses orapplications. More particularly, it relates to systems and protocols forusing one or more commonly accessible registries to transform electroniccommerce documents among dissimilar interfaces, preferably XMLdocuments. Particular aspects of the present invention are described inthe claims, specification and drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a high-level block diagram of a prior art transformationprocess using point-to-point connections.

FIG. 2 is a high-level block diagram of the transformation process usinga web services engine.

FIG. 3 is a hierarchical block diagram of document families andversions.

FIG. 4 is a block diagram of document libraries, namespaces, schemas anddocument families.

FIG. 5 is a network diagram of document family members and transformsamong members.

FIGS. 6 and 7 are tables for transform sequences and logic componentsused to carry out transform sequences.

FIG. 8 is a class diagram including document libraries, namespaces,document types and schemas, document families and transforms.

FIG. 9 is a high-level block diagram of a software component thatcarries out transforms.

FIG. 10 is a corresponding activity diagram.

FIG. 11 illustrates sequences of transforms.

FIGS. 12 and 13 are flowcharts depicting aspects of determining thepreferred sequence of transforms to convert a source document into atarget document.

FIGS. 14 and 15 illustrate user interfaces that support administrationof document families and searching to find transforms.

DETAILED DESCRIPTION

The following detailed description is made with reference to thefigures. Preferred embodiments are described to illustrate the presentinvention, not to limit its scope, which is defined by the claims. Thoseof ordinary skill in the art will recognize a variety of equivalentvariations on the description that follows.

FIG. 2 depicts supplier processing of incoming purchase orders destinedfor four disparate systems. Incoming purchase orders originate fromthree sources 201, an EDI buyer, an online store customer and anOAG-compliant buyer. The native formats utilized by the three sources201 may include EDI, XML and OAG. Four target systems 206 include an SAPFinancial system, an SAP MRP system, a Biz IQ system and a Graingershipping system. The native formats accepted by these target systems 206include IDOC, BAPI, OAG and a custom API. In this system, a web servicesengine 211 performs semantic transformations using a common syntacticbase. For instance, EDI and OAG documents are converted to XML, as acommon syntactic base. Transformations from XML to XML handle semanticdifferences between the source and target document. XML documents may bereconverted to native formats such as EDI, OAG, IDOC, or BAPI. Thesyntactical transformations to and from XML may be handled as part ofthe web services engine 211 or by the interfaces or adapters 202, 205associated with the source 201 and target 206.

The web services engine 211 has access to a variety of transforms 213,including transforms using the common syntactic base. These transformsmay be reusable. More than one transform may be invoked to convert adocument from source semantics to target semantics. It may be desirableto utilize a common semantic base for transformations, for instance,transforming incoming documents to a well-understood document schema,such as the xCBL schema for electronic commerce documents 212. Bytransforming incoming documents to a common semantic base, the need forpoint-to-point transforms is minimized. The transforms may be chainedand may be reusable. The transforms may be isomorphic or homomorphic.That is, the transforms need not be perfectly reversible. The transformstypically will be rated, either a priori or by comparing source andtarget semantics before and after transformation, to estimate the degreeof loss resulting from the transform. A transform success score can beused to select among alternate sequences of transforms from source totarget semantics. Loss resulting from transforms can be compensated forby including in the target document one or more fields that captureimperfectly translated information from the source document. Thesefields may be user viewable, so that a user associated with the source,the target or an intermediary service provider can respond toimperfections in the computer-implemented transformation service.Alternatively, the source document and target document can be sent tothe target, with references to parts of the source document that havebeen imperfectly transformed or that are suspected of having beenimperfectly transformed. These references can be part of the targetdocument or a separate document, such as an error document. They can bea string, a pointer or some other form of reference. References can beprovided to one or more sections of the target document where theimperfectly transformed information belongs. The references to thetarget document may be to an element or subsection of the targetdocument or to a specific location within an element or subsection. Inyet another embodiment, the target document and excerpts of the sourcedocument can be sent to the target, with references to the excerpts ofthe source document and, optionally, to the target document.

A commonly accessible registry, partially illustrated in FIG. 2,facilitates management of the community using XML schema definition(XSD)-based XML electronic commerce documents or, more generally, aschema for a syntax using character data encoding text characters andmarkup data identifying sets of storage units according to the logicalstructure of the documents. Maintaining transformations in at least onerepository facilitates reuse, both in design of needed transforms andexecution. A commonly accessible repository of transforms also permitsdistributed execution. The web services engine may use resources of thesource, target, or an intermediary service. Upon determining theinterfaces used by source and target, appropriate transform logic can beobtained from the commonly accessible registry or a cache in whichtransform logic previously obtained from the commonly accessibleregistry is kept. Interoperability is established at runtime, based onentries in one or more registries and logic residing in one or morerepositories. At runtime, connections are dynamically determined betweensource and target. When source or target implements a version change,the dynamic determination of the connection accounts for the versionchange.

A commonly accessible registry can provide a so-called semantic hub. Thecommonly accessible registry may maintain service descriptions for theapplications that provide services, such as electronic commerceservices. Inbound and outbound document interfaces are registered aspart of the service descriptions, preferably in the form of XSDdefinitions. A service is free to register multiple interfaces, forinstance to support multiple versions of an electronic commerce documentstandard (e.g., xCBL 2.0, xCBL 3.0, or xCBL 3.5) or to support multipledocument standards (e.g., xCBL, IDOC, OAG, or BAPI). The introduction ofdocument family concepts provides a way to manage schemas and documenttypes across documents standards and standards versions, as well ascustom systems. Document families associate document types thatrepresent the same business events into families. Transformation maps ortransforms manage standard and custom logic to convert among documentfamily members. A cost of using a particular transform may reflectimperfect translation of the document. Again, a transform success scorecan be associated with the transform either a priori, based on priorexperience, or by dynamically comparing the semantic content of thedocument before and after application of the transform.

Maintaining transforms using XML as a common syntactic base ispreferred, but not necessary. XML is a rich, self-describing datarepresentation that facilitates declarative mapping logic. Severalsemantic bases, such as xCBL component model, provide a consistentsemantic base to harness XML's powerful semantics. Modeling of XMLdocuments to a semantic registry facilitates reuse and rapid developmentof new transforms, thereby enhancing the value of existing transforms.Focusing on semantic mapping, with a common syntactic base and even acommon semantic base, reduces the complexity of developing newtransforms. Business analysts, instead of programmers, may be able touse transform-authoring tools to define XML-to-XML semantic conversions.

A document family, as illustrated in FIG. 3, allows for categorizationand grouping of documents. Related documents are grouped under the samedocument family 300. Documents may be specified by a documentidentifier. The document identifier logical construct is used torepresent a root element of a message, for instance a root element of anXML electronic commerce document. A document identifier may specify adocument ID, its relationships, versions and family associations. BothXML and non-XML documents may be assigned document identifiers andstored in a common registry. Attributes of the document identifier mayinclude a document identifier (e.g., the name “Order”); the namespace(e.g., urn:x-commerceone:document:com:commerceone:XCBL30:XCBL30.sox); adocument library name (e.g., a xCBL, DTD, EDIFACT); a schema language(e.g., SOX, XSDL); a version (e.g., 3.0); and the document family name(e.g., PurchaseOrderFamily, PriceInquiryFamily, QuoteFamily). Thedocument family organizes documents by document identifier in ahierarchy of versions. In FIG. 3, the document family tree 300 or otherdata structure is used to organize individual families 310, 320. Apurchase order family 310, for instance, may include one or more majorversions 311, 312, 313. One or more of the major versions may beassociated with minor versions (not illustrated), in a similartree-structure. A version attribute may record both major and minorversioning. One possible differentiation between major and minor visionswould be that major versions have significant changes that requiretransformation, whereas minor versions have no structural differences,only sub-element extensions. Users of the system may commonly extend adocument's sub-element without modifying the doctype itself. Thissub-element extension can be treated as a minor version, in the same waythat modification of the doctype is handled. Therefore, the doctype noderepresents the doctype schema and all the schemas that make up thedoctype element. For example, if the LineItem element is extended, andthis extended type is used in instance of the PurchaseOrder, then thePurchaseOrder doctype is versioned. When sub-elements are versioned,users register new doctypes. They specify the parent doctype node andassign a new minor version relationship to the parent. A version ID isgenerated and assigned to the new node.

A registry may subdivide schemas into namespaces, as illustrated in FIG.4. XML, namespaces (e.g., XSD, SOX, RosettaNet, CIDX) and non-XML,namespaces (e.g. EDI, EDIFACT) can be registered and managed using aschema namespace management component. A schema namespace may havevarious attributes including: a namespace URI; name; classification,namespace status; validation status (for XSD namespaces); namespaceversion; description; document library name; schema language (for XSDtype namespaces); schema files; bean jar file name; dependent namespaces(if any, for XSD and SOX type namespaces); and external or informationalURLs. Typically, different versions of namespaces will have differentURIs. For instance, document libraries for major xCBL version 3.0 401and for major xCBL version 3.5 402 may have one or more namespaces (411,412, 413) and 414, respectively, that can be used to support minorversions. One way of maintaining a schema is to use n files for ndocument schemas. A namespace manager may store meta data about thenamespace, the schema files associated with the namespace and the Javajar file containing JavaBeans and classes corresponding to the schemafiles. A graphical user interface using a browser-based tool may be usedto manage registration, activation, deactivation and deletion ofnamespace sets. Published namespaces may be first validated, includingassociated schema files, with tools such as the validation API from XMLtools (XDK). In FIG. 4, there are two document libraries 401, 402. Eachof the document libraries includes three schema namespaces (411, 412,413) and 414, respectively. Name spaces are associated with schema files421-425 and 426. Working back up the tree from a namespace family 431for purchase orders, for instance, two purchase orders of xCBL 3.0 andxCBL 3.5 types, 432, 433, respectively, are associated with particulardocument schemas 421, 426, respectively.

FIG. 5 presents another view of the document family, depicted here as anetwork of document family members interconnected by transforms. In thispurchase order family, documents 501, 502, 503 are identified bylibrary, document identifier, version and schema type. For instance,document 501A is from the xCBL library, identified as an Order, version4.0, using the schema type XSD. Document 501C is also from the xCBLlibrary, identified as an Order, version 3.5, using schema type SOX.Document 502A is from the X12 markup library, identified as an 850document, version 4200, using schema type XSD. Document 502B is customflat file document marked up in XML. This is the kind of document thatcould be prepared with a template and word processor, for instance. Inthis figure, separate transforms identified for each direction ofconversion between document family members. Transform types identifiedincluded Contivo maps, XST maps, XSLT maps, Java classes translatingbetween XSD and SOX, Java substring substitutions and Java maps (XDK).Different transform types may be used for transforms and inversetransforms between document family members. The system can be adapted tonew or different transform types, for instance, as extensions ofexisting classes. For instance, translating from xCBL version 3.5 501Bto xCBL version 3.0 501F involves applying an XSLT transform.Translating the opposite direction involves applying a Java component.The network of document family members interconnected by transforms canbe considered a directed graph, in the sense that interconnectionsbetween nodes (document family members) are directed links (onedirectional transforms) having different attributes. Well-knownalgorithms can be applied to traverse this network while avoiding loopsor circular references. Not illustrated in this diagram, an a prioritransform success score or an experience-based transform success scorecan be associated with each of the transforms that link document familymembers.

FIGS. 6 and 7 depict tables that may be used to identify transforms in adocument family such as depicted in FIG. 5. These tables can be accessedat runtime by a transformation engine to identify a preferred transform.Some transforms may be cached. In FIG. 6, the transformation from onedocument family member 601 to another 602 is accomplished by applyingone or more logic components 611 in the order listed. These logiccomponents can be Java class files, XSLT maps, XST maps, or any othergeneric or custom transform, accommodating current and future documentstandards and transformation standards. The transform success score 610measures the imperfection resulting from translating the source 601 tothe target document 602. In this example, the transform entries areindexed by the source and target document attributes. These attributesets comprise the document family namespace, family name, protocol,schema language, doctype, XML QName, and version ID. When searching fortransform entries, wildcards can be used in the search. Transformentries may optionally contain flags for special rules 603-608. Customtransformations can be applied at the trading partner level, servicelevel or action level. The source or target trading partner ID can beflagged 603, 604 to indicate that the special logic components should beused for particular source or target trading partner. Similarly, serviceand action can be flagged 605-608 to indicate that special logiccomponents should be used for particular source or target service oraction. The transformation engine should use the most specific transformdefinition available. For instance, a definition that is specific to atrading partner, service and action triplet would be considered morespecific to transform designated only by trading partner. Hierarchicalimportance may be assigned to trading partner, service or action, incase different elements of the triplet are defined for differenttransforms. For instance, trading partner may be considered moreimportant than service if two transforms match the source and targetdocument types, one transform which is specific to a trading partner andthe other which is specific to a service. Other attributes of thetransformation may evoke special rules. The present invention is notlimited to special rules categorized by trading partners, services andactions. FIG. 7 provides additional information regarding logiccomponents 701 used as components of transforms in a column 611. Forlogic components 710, a type 702, an implementation 703, a configuration704, a package 705 and a version 706 may be supplied.

FIG. 8 depicts classes that may be used to represent a document family.Some aspects of these classes correspond to logical structures depictedin FIGS. 3 and 4. Document library 801 is the highest level oforganization for documents and schemas. The name of a document libraryis represented by a string, such as “xCBL.” A library optionally may beversioned 802. The library version is represented by string. For aversioned or unversioned library, namespaces may be provided 811. Amongnamespaces, there may be dependencies, as indicated by the relationshiploop that points from the namespace class back to the namespace class.Attributes of the namespace include a namespace URI, a name, aclassification, a schema language, a namespace status, a validationstatus, a namespace version and a description. These attributes may beexpressed the strings. In addition, flags or flag values may be providedto indicate whether the namespace is active, inactive, depreciated ordepleted. Flags or flag values also may be provided indicate whether thenamespace is validated or not validated. Associated with the namespaceare an external link 803, global elements 821, schema files 824 andexternal files 827. In this embodiment, the namespace may be externallylinked by a URL to a uniform resource name. A description of theexternal link 803 also may be provided. The namespace may be linked to aset of global elements 821. These global elements express valid rootelement names of XML documents, which correspond to document typesrecognized in the namespace. This class of global elements may beredundant to data maintained in other classes. The namespace also may belinked to a set of schema files 824. Two distinct links may be provided,to root schema files and to other schema file containers. The rootschema file is the root file that joins or includes the other schemafiles. Dependencies among namespaces are modeled, allowing all schemafiles for a namespace and all dependent namespaces to be retrieved, aswell as to ensure that schemas are not accidentally removed leavingother namespaces in inconsistent states. Attributes of a schema file mayinclude a filename string and a relative path string. An absolute pathmay alternatively the provided. A schema file element 824 is representedby an external file 827. The external file object is used to model thephysical location of a file and can be referenced by any entity thatrequires a physical file representation. This external file may, forinstance, be a bean jar file linked directly to the namespace.

The namespace is linked to documents and document families, in thisembodiment, through the document ID class 812. The document ID 812 mayactually have two types of links to a namespace, one of which is theroot namespace it belongs to, and the other which is used for extensionnamespaces. This supports major versions and minor versions. A majorversion document ID may be a brand new version of a document that doesnot extend a previous version of a document. A minor version document IDmay extend either a major or minor version document ID. A major versiondoc ID will only have a single namespace relationship, which referencesthe namespace within which the root element is defined. A minor versiondoc ID references the super parent (major version) doc ID's namespace,along with any other namespaces within which any extensions exist. Thedocument ID 812 may be associated with the document family 804, anexternal ID 805, document rule 813, a transformation map 823 and an XMLdocument ID 822. Attributes of a document ID may include a name, a URIand a primary alternate URI. A URI is automatically generated for a docID using three components: namespace URI, DocID Name, DocId version.This Doc Id URI is used to refer to this Doc ID. If a user desires acustom Doc ID naming scheme, they may enter their own URI, and this isset in the primaryAltId relationship. Users may also have more than onenaming scheme, in which case the otherIds relationship models thesenames. All these names should be unique. Attributes of a document ID mayfurther include a display name, a description and a document version.All of these attributes may be maintained as strings. A specializationof document ID is XML, document ID 822, for XML documents. Attributes ofthe specialization may include an XML element name, a version type, abean class name and major and minor versions. As characteristic of XML,a relationship loop indicates that XML document IDs may represent nestedelements. An external ID 805 may be associated with the document ID 812.The external ID 805 may be a registry key or an alias for a URI. Both aprimary, default link and one or more user supplied aliases may link thedocument ID and external ID.

Document ID rules 813 may be sufficiently generalized to supporttransforms, validations, and display maps. Transforms 823, sometimescalled transformation maps, are a specialization of the document ID rule813. Logic implementing the transform is linked to a document ID rule813 through a set of transform components 825. A transform component, inturn, is linked to an external file 827. Attributes of thetransformation map 823 may include a cost or transform success score, atransformation URI and a location URI. The transformation URI uniquelyidentifies a transformation map within a registry. A location URI is anoptional identifier that indicates where the transformation should takeplace. For example, if only one host within a network is capable ofperforming the transformation, its URI is assigned to the location URIattribute and the transformation/router will send the transformation tothis host to be performed. Attributes of the transformation component825 may include a transformation component URI, a name, description,component type, implementation file, package name and execution order.Transformation components 825 are linked as a set to the document IDrule 813. The execution order attribute confirms the sequence in whichtransforms are applied, if more than one transform is required. In thisembodiment, transform logic may include one or more of an XSLT map, andXST map, a Java component, or a Contivo map. Transform components arelinked to set of configuration elements 826. Attributes of theconfiguration element may include a name and a value. Document ID rules813 are also linked to a set of map context strings 814. These stringsassociate the document ID rule 813 and with a particular trading party,either a sending/source or receiving/target party, or with a particularservice or action, as described above in the context of FIGS. 6 and 7.

Logic to retrieve and execute transforms may conveniently be accessedthrough an XML transformation module (XTM), as illustrated in FIG. 9.The XTM module is supported by a registry service 905, which servestransformation logic from local and remote registries. A registry clientapplication program interface 904 maintains transparency as to whether atransform is retrieved from a local cache or registry 906 or a remoteregistry. A retrieved transform or transform reference may be passed toa document transformation application program interface 907, which, inthis embodiment, includes resources for various transform types 908. Ifin alternative embodiment, the registry client API 904 may be invokedfrom the document transformation API 907, also called a documenttransformation service. The document transformation service 907 may beinvoked by an XTM module 902 either in the services home community orfrom a remote community, such as a community that is sending documentsto the home community. An upgrade to the transformation service mayinvolve adding a new type of transform 908 and new version of thetransformation engine 907. Connectors between XTM modules and documenttransform APIs may be upgraded in phases, after upgrading the documenttransformation API 907 and the component transforms 908. A documenttransformation service may be invoked from a different community thanthe home community. For instance, a service sending a purchase orderfrom community A to community B may invoke the service homed incommunity B. To perform the transform required so that the PO preparedusing community A's semantics will be acceptable to community B, it maybe necessary to invoke a transform that only runs on the transformationengine in community B. In this case, the XTM module in community A willinvoke the document transform API in community B to remotely execute oneor more transforms, converting the purchase order from community A'ssemantics and to community B's semantics.

The transformation may be identified in the inbound message 901, whichmay but preferably does not include the details of which transformsshould be applied to accomplish the transformation. In FIG. 10, aso-called interoperability contract document (ICD) 1011 is transmittedto the XTM 1001, in the same envelope 901 as the message to betransformed. The ICD may include a path of transformation instructionsand connectors along a route to carry a document from source to target.In one embodiment, the XTM module is associated with a connectorcomponent in a community of B2B applications, which community may belongto one or more networks of communication. The XTM module may access theICD and determine whether the transformation instructions that itcontains identify its connector as performing any transformation. Ifthere is no transformation to be performed by the current connector orits XTM module, the XTM module may return success and, optionally, maylog a pass-through event. If a transformation is to be performed by thecurrent XTM module, it parses the transformation instructions andobtains 1002, 1003 a sequence of transforms be executed from theregistry client API 1002. The XTM extracts a source document from theenvelope 901. It matches the source document attributes with the firsttransform to be performed and indicates an error if there is a mismatch.It invokes 1014 the document transform API 1003, with the list oftransforms to be retrieved and performed. If an error is generatedduring the transform process, the error may be noted, or the transformmay be aborted and an error message returned. The XTM module 1001 mayarchive the source and transformed target documents for security,non-repudiation, debugging or other purposes (not illustrated). The XTMmodule determines whether the target prefers to have the source documenttransmitted, as well as the transformed target document, and if so,attaches it when it creates 1016 the outgoing envelope 903. The XTMmodule should be implemented in a thread-safe manner. The transformedenvelope 903, is returned 1017.

An ICD is contained in the same envelope 901 as the message to betransformed, may use the following schema to identify a transformationrequired:

<?xml version=“1.0” encoding=“UTF-8”?> <xs:schemaxmlns:xs=“http://www.w3.org/2001/XMLSchema”elementFormDefault=“qualified” attributeFormDefault=“unqualified”><xs:element name=“TransformationContract”> <xs:annotation><xs:documentation>Transformation Instructions</xs:documentation></xs:annotation> <xs:complexType> <xs:sequence> <xs:elementname=“Attachment” type=“xs:boolean” minOccurs=“0”/> <xs:elementname=“Transformation” minOccurs=“0” maxOccurs=“unbounded”><xs:complexType> <xs:sequence> <xs:element name=“Connector”type=“xs:anyURI”/> <xs:element name=“StartDocTypeName” type=“xs:QName”/><xs:element name=“StartDocVersion” type=“xs:string”/> <xs:elementname=“EndDocTypeName” type=“xs:QName”/> <xs:element name=“EndDocVersion”type=“xs:string”/> <xs:element name=“CommunityID” type=“xs:string”minOccurs=“0”/> <xs:element name=“ComponentID” type=“xs:string”maxOccurs=“unbounded”/> </xs:sequence> </xs:complexType> </xs:element></xs:sequence> </xs:complexType> </xs:element> </xs:schema>

An example of transformation instructions, according to schema above,is:

<xs:element name=“Transformation” minOccurs=“0” maxOccurs=“unbounded”> <xs:complexType> <xs:sequence>  <xs:element name=“Connector”type=“xs:anyURI”/>  <xs:element name=“StartDocTypeName”type=“xs:QName”/>  <xs:element name=“StartDocVersionID”type=“xs:string”/>  <xs:element name=“EndDocTypeName” type=“xs:QName”/> <xs:element name=“EndDocVersionID” type=“xs:string”/>  <xs:elementname=“CommunityID” type=“xs:string”  minOccurs=“0”/>  <xs:elementname=“ComponentID” type=“xs:string” maxOccurs=“unbounded”/></xs:sequence>  </xs:complexType> </xs:element>In this example, the source document type is identified byStartDocTypeName and StartDocVersion. The StartDocTypeName should be afully qualified document type, a QName in XML, terms, including anamespace and local name of the root element for the document type.Alternatively, a unique naming convention could be used, withappropriate administrative provisions to enforce uniqueness within arelevant scope. A version identifier should be supplied to distinguishamong variations of the same document. A customer may extend an addresselement within a purchase order, for instance, and the extensions willhave a different minor version ID than the major version. EndDocTypeNameand EndDocVersion identify the target document resulting from thetransform. Community ID specifies the community where the transform isregistered. Component ID is used to look up the transform logic, forinstance via the transformation component 825.

One implementation of an ICD specifying the target's preference toreceive (or not) the original, source document in addition to thetransformed target document is expressed in the following schemaexcerpt:

<xs:element name=“TransformationContract”> <xs:annotation><xs:documentation>Transformation Instructions</xs:documentation></xs:annotations <xs:complexType> <xs:sequence> <xs:elementname=“Attachment” type=“xs:boolean” minOccurs=“0”/>The attachment tag will indicate whether the original, source documentshould be attached or not. A default, in the absence of this element,may either be to attach the document or not to attach it.

FIG. 11 depicts chaining of transforms to convert a document from sourcesemantics to target semantics. In this figure, the document state isindicated by a block and a state-to-state transform is indicated by asolid or dotted line. The solid and dotted lines indicate alternativetransforms. These transforms may be public and private transforms or maybe generally applicable and specially selected transforms. In the firstexample, source 1101 desires to send a purchase order to target 1104.The document standard or native interface of the source is IDOC. Thedocument name and version for this purchase order, within IDOCsemantics, is ORDERS2. The schema type is XSD. The native interface ofthe target is OAG. The document name is Purchase Order. The version forthis purchase order is 7.2.1. The schema type is XSD. In this example,transforms from both the source or sender registry 1131 and the targetor receiver registry 1132 are used. The series of transforms is traced1141. The source document is subject to source registry 1131 transforms1101-1102 and 1102-1112. These transforms convert the ORDERS02 documentto an xCBL version 4.0 Order document. Two additional transforms1103-1113 and 1113-1104 from the target registry 1132 are applied next.Thus, by application of four transforms, the IDOC interface document isconverted to an OAG interface document. In this instance, the commonintermediate semantic base is xCBL. By inspection of FIG. 11, it becomesapparent that three transforms from the sender registry 1131 and asingle transform from the receiver registry 1132 could, alternatively,have been used to convert the IDOC interface document. An alternativepath would have been to convert from a xCBL version 4.0 to version 3.5using a transform 1112-1122 in the sender registry 1131. Then, thereceiver registry 1132 transform with similar functionality 1103-1113would not need to be used. The choice of paths 1141 for this conversionmay be explained by the dotted line in the receiver registry between1103 and 1113. This implies that the target preferred use of its owntransform for conversion between versions 4.0 and 3.5. In the secondexample, source 1121 desires to send its XYZ Order to target 1124. Threetransforms 1121-1122, 1113-1123, and 1123-1124 are used 1142. Again, thesemantic base for transforms is xCBL. A custom transform is used toconvert the marked up flat file to xCBL version 3.5. Non-customtransforms are used thereafter to convert the document to X12 markupformat. While these examples illustrate transforms stored in both sourceand target registries, other configurations of registries may equallywell be used, such as a single common registry or a common registry andsupplemental registries for sources and targets with custom logiccomponents.

More detail regarding computation of transform sequences using bothsource and target registries of transforms is provided in flowchartFIGS. 12 and 13. FIG. 12 is an overall flowchart. FIG. 13 depicts one ofmany algorithms that can be used to trace paths through one or moreregistries of document family members. FIG. 12 begins 1201 withinformation about the source document and identifications of the sourceand target. The source document is described by a document typeattribute set. The source and target are described by a triplet ofparty, service and action. The first logical branch 1202 determineswhether a policy against transformations has been set. This type ofpolicy might apply where the target wants the source to bear all risk ofan erroneous transformation, so use of public transform elements is atthe source's own risk. If there is a policy against transformation, a notransform instruction message is returned 1211. Passing the logicalbranch 1202, the document type of the target is retrieved 1203. This maybe from a registry, as described above. Give information about thesource and target documents, alternative transform sequences or pathsare determined 1204, which may include transform success scores for thepaths and also may include transform preferences of the source andtarget. The list of alternative paths is inspected and candidate pathsthat produce the desired target document type are identified 1205. If nopath producing the desired target document type appears in the list, ano transform instruction message is returned 1211. Passing the logicalbranch 1206, a preferred path is selected and extracted 1207. Thepreferred path may have a preferred transform success score or it mayconform to transform preferences of the source, target or both.Transform instructions are created 1208 and returned 1209.

FIG. 13 illustrates tracing transform sequence paths through source andtarget registries, beginning from a particular document family member.In overview, the algorithm queries the source and target registries forthe intersection of identical document types in the source and targetdocument families. It performs integrity and error checks notillustrated in the figure. For each part of a multi-part message, itdetermines the target document and runs a cost algorithm thatrecursively traverses a document family graph, following transform linksbetween document state nodes. If the document type of a node is amongthe intersection of identical document types previously determined, thealgorithm splits into a path through both registries. If atransformation policy applies that requires lossless transformation(perfect transform success scores), then lossey transform paths areignored. This traversing and costing are a variation on Dijkstra'salgorithm for solving a single-source, shortest-path problem on anedge-weighted graph in which all the weights are non-negative. It findsthe shortest paths from some starting node to all other nodes,one-by-one. Paths are traversed, in Dijkstra's algorithm, in order oftheir weighted lengths, starting with the shortest, proceeding to thelongest. In general, any traversal of the applicable document familiesfrom source document to target document may be used, and documentfamilies may be small enough that the particular traversal used hasminimal impact on computational costs.

Referring to the flow chart in FIG. 13, this part of the algorithmbegins 1204 with a start node or document family member, andparty/service/action triplets identifying the source and target. At step1301, an intersection of nodes between source and target registries iscalculated. For instance, do both source and target process xCBL version3.0 or xCBL version 3.5 documents? If there is no intersection betweendocument semantics processed by the source and target, no transformsequence is available. Referring to FIG. 11, the intersection would bexCBL versions 4.0 and 3.5 (1112 to 1103 and 1122 to 1113). Lists aremaintained by this processing algorithm of SourceNodes, ProcessedNodesand transform sequences. Some or all of these lists may be maintained instacks or heaps of recursively allocated and processed variables.Referring to FIG. 5, boxes (e.g., 501, 502 or 503) are SourceNodes fromwhich a walk of the directed graph proceeds. SourceNodes may be labeledor unlabeled, depending on the progress of the walk. The walk begins byadding the StartNode to the list of SourceNodes 1302. The list isprocessed in a loop bounded by 1303 and 1305 and by an inner loopbounded by 1311 and 1324. At 1303, processing of a so-called iNode inthe SourceNodes list begins. The current iNode is labeled. Then,connected members of the document family that have not yet been labeledare considered 1311. For instance, referring to FIG. 5, for iNode 501B,the connected document family member nodes would be 501A, 501C, 501F and502C. The connected nodes that are unlabeled are called yNodes 1311. AyNode is tested 1312 to determine whether it is in the ProcessedNodeslist and, if not, it is added to the list 1321 and processed 1313. Ifthe yNode is in the ProcessedNodes list, the algorithm determineswhether the current path to the yNode is better than previouslycalculated paths. At step 1313, the cost of reaching the current yNodeis compared to the previous cost of reaching the same node. If thecurrent cost is better than the old cost, processing proceeds to step1314, where the ProcessedNode list is updated. At step 1315, yNode isadded to the SourceNodes list for later processing. Again at step 1313,if the current cost is not better, then processing proceeds to step1322, which tests whether the costs are the same. If the costs are thesame, then a variety of criteria might be used to break the tie 1323.One criterion is to favor an instance of yNode that is in the receiver'sregistry, when the same node appears in both the receiver's and sender'sregistries. Another criterion would be to favor an instance of yNodethat is in the sender's registry. Yet another criterion would be tofavor the path that involves the fewest nodes or hops. At step 1324,processing loops to 1311, where the next connected node that is notlabeled is processed. If the unlabeled connected nodes all have beenprocessed, the next step is 1305, at which processing loops to 1303where the next iNode in SourceNodes is processed. When all SourceNodeshave been processed 1305, the results of this processing are returned1306.

The calculation of alternative transform sequences and preferredtransform sequences may operate in different environments. The followinguse cases illustrate some of these environments. In the first use case,no transformation is required. The module for determining a transformsequence is invoked, but the source and target documents are the sametype. No transformation is required. In the second use case, notransformation is available between source and target. This may be thecase when no transform sequence can be calculated between differingsource and target documents, or when transformation policy is “notransforms” and the source and target documents differ, or when only alossless transformation is accepted but all calculated transformsequences are lossey, as indicated by their transform success scores. Anoperating exception occurs. In the third use case, the source and targetare in the same community, so only one transform registry is queried anda valid path exists. One or more transform sequences are determined. Apreferred sequence is determined. In a fourth use case, the source andtarget are in separate communities and a valid path exists. Twotransform registries are queried. As in the third case, one or moretransform sequences are determined and a preferred sequence isdetermined.

Transform success scores, as described above, can be determined apriori, by experience or dynamically, or, more generally, by any metricof a lossey semantic transform. An a priori score is assigned to atransform based on some combination of analysis and tests. The scoredoes not change with experience. An experience based score may beginwith an a priori score or a default score, and be adjusted withexperience. For instance, methods of dynamically computing success,explained below, can be applied for selected transforms that are used,and the corresponding transform success score updated, for instance as aweighted or moving average, either discarding an oldest historicalsuccess score or assigning relative weights to past and present successscores. One approach to dynamically determining success scores is toapply a transform to the candidate document and analyze the transformeddocument. The transform is applied to the source or intermediate sourcedocument, producing a target or intermediate target document. Thecontent of elements (in an XML or similar document) is listed for sourceand target documents, for instance in a frequency table. Discrepanciesbetween the source and target frequencies reduce the transform successscore, regardless of whether the difference is positive or negative. Thediscrepancies optionally are reported. The success score can depend onexact matches between element contents, or may be weighted by degree.The following example helps illustrate this approach to dynamic scoring.The source document fragment is:

<NameAddress> <Name>Pikachu Pokemon</Name> <Address1>125 HendersonDrive</Address1> <City>Pleasanton</City> <State>CA</State> </NameAddress >The transformed target document fragment is:

<NameAddress> <Name>Pikachu Pokemon</Name> <Street>HendersonDrive</Street> <HouseNumber>125</HouseNumber > <City>Pleasanton</City><State>CA</State> </NameAddress>

A frequency comparison, based on elements of the source documentfragment and keyed to exact matches would be:

Source Doc Target Doc Content frequencies frequencies Pikachu Pokemon 11 125 Henderson Drive 1 0 Pleasanton 1 1 CA 1 1

A dynamic transform success score corresponding to the fraction offields in the source document that appear verbatim as fields in thetarget document can be expressed as a success of 75 percent or a cost of25 percent could be assigned to this example. A different score would beassigned if partial matches counted, as the house number element of thetarget document matches one token of the address1 element of the sourcedocument. The success score could correspond to the fraction of the textin fields of the source document that appears verbatim in fields of thetarget document. Application of a sequence of scores requirescalculation, for some purposes, of an aggregate success scores. Whenindividual scores are combined into an aggregate transform successscore, the combination may be additive, averaged or multiplicative. Themethod of constructing an aggregate transform success may take intoaccount the number of transforms in sequence, as in the multiplicativecombination of success scores or may accumulate (without compounding)the errors, as in the additive combination of costs. For instance, inthe multiplicative combination, if the transforms are T1, T2 and T3,loss percentages can be calculated for each of the three and combined as(1−T1)*(1−T2)*(1−T3). More generally, an aggregate transform successscore may be any metric of a sequence of transforms resulting in alossey transformation from source to target document.

User interfaces for administering document family information and forsearching for transforms are illustrated in FIGS. 14 and 15. FIG. 14depicts a user interface supporting administration of document families.A document tree 1401 shows the hierarchical interrelationship of major1403 and minor 1404 versions of a document 1402. For a family, documentfamily information common to family members is displayed 1411. FIG. 15depicts a user interface supporting a search to find availabletransforms, for instance, to prepare a new transform sequence. Theresults displayed 1511 identify part of 23 transform sequences thatconvert a source document (PurchaseOrder, CBL, SOX, Y, 200) from xCBLversion 2.0 to version 3.0. The search criteria are specified using astandard 1501 or advanced 1502 query interface. One or more rows of theresults can be deleted 1512 or used to create a new transformation 1513.In this example, the transform sequences returned vary by expressedpreferences of sending party 1514 or receiving party 1515, cost orlosseyness of the transform 1516 and logical components implementing thetransform sequence 1517.

While the present invention is disclosed by reference to the preferredembodiments and examples detailed above, it is understood that theseexamples are intended in an illustrative rather than in a limitingsense. Computer-assisted processing is implicated in the describedembodiments. Accordingly, the present invention may be embodied inmethods for computer-assisted processing, systems including logic tocarry out transform processing, media impressed with logic to carry outtransform processing, data streams impressed with logic to carry outtransform processing, or computer-accessible transform processingservices. It is contemplated that modifications and combinations willreadily occur to those skilled in the art, which modifications andcombinations will be within the spirit of the invention and the scope ofthe following claims.

We claim as follows:
 1. A method including: maintaining a documentfamily registry data structure for a particular document familyincluding document family members, the document family registry datastructure including: document family versions, transforms includingprogram instructions that transform data between document familyversions, and associations of the transforms with source document familymembers and target document family members; and responding to requestsfor transforms to convert a document from a source version to a targetversion by: traversing the document family registry data structure as adirected graph, and providing one or more sequences of transformsdetermined by the traversing.
 2. The method of claim 1, wherein thedocument family versions in the document family registry data structureare identified by library, document identifier, release version andschema type.
 3. The method of claim 1, wherein the one or more sequencesof transforms includes one or more of Contivo maps, XSLT maps, XST maps,XSD-SOX classes, and Java maps.
 4. The method of claim 1, wherein theone or more sequences of transforms is stored in a local repository andis checked against a non-local repository for currency beforeapplication.
 5. The method of claim 1, wherein: the maintaining of thedocument family registry data structure further includes maintainingtransform success scores; and the traversing of the document familyregistry data structure further includes calculating composite transformsuccess scores for the one or more sequences of transforms.
 6. Themethod of claim 5, wherein the transform success scores correspond to afraction of fields translated verbatim from a field of the sourcedocument to a field of the target document.
 7. The method of claim 5,wherein the transform success scores correspond to a fraction of text infields of the source document found verbatim in fields of the targetdocument.
 8. The method of claim 1, wherein: the maintaining of thedocument family registry data structure further includes maintainingspecial rules for transforms to be applied corresponding to one or moreparticipants in a document exchange; and the providing further includesreferring to privately maintained transforms, maintained separately fromthe document family registry data structure.
 9. The method of claim 1,wherein the providing further includes referring to privately maintainedtransforms, maintained separately from the document family registry datastructure.
 10. A method including: maintaining a document familyregistry data structure for a particular document family includingdocument family members, the document family registry data structureincluding: document family versions; and transforms including programinstructions that transform data between document family versions; andresponding to requests, which identify a first document family versionand a second document family version, by providing a transform to beexecuted remotely and that transforms the data from the first documentfamily version to the second document family version.
 11. The method ofclaim 10, wherein the document family versions in the document familyregistry data structure are identified by library, document identifier,release version and schema type.
 12. The method of claim 10, wherein theone or more sequences of transforms includes one or more of Contivomaps, XSLT maps, XST maps, XSD-SOX classes, and Java maps.
 13. Themethod of claim 10, wherein the one or more sequences of transforms isstored in a local repository and is checked against a non-localrepository for currency before application.
 14. The method of claim 10,further including traversing the document family registry data structureand identifying one or more sequences of multiple transforms thatcollectively transform from the first document family version of asource document into the second document family version of a targetdocument.
 15. The method of claim 14, wherein: the maintaining of thetransforms further includes maintaining transform success scores; andthe responding to requests further includes calculating compositetransform success scores for the one or more sequences of multipletransforms.
 16. The method of claim 15, wherein the transform successscores correspond to a fraction of fields translated verbatim from afield of the source document to a field of the target document.
 17. Themethod of claim 15, wherein the transform success scores correspond to afraction of text in fields of the source document found verbatim infields of the target document.
 18. The method of claim 10, wherein themaintaining of the document family registry data structure furtherincludes maintaining special rules for transforms to be appliedcorresponding to one or more participants in a document exchange. 19.The method of claim 10, wherein the transform to be executed remotely isa privately maintained transform that is maintained separately from thedocument family registry data structure.
 20. The method of claim 10,wherein: the maintaining of the document family registry data structurefurther includes maintaining special rules for transforms to be appliedcorresponding to one or more participants in a document exchange; andthe responding further includes referring to a private transform that ismaintained securely within the document family registry data structure.21. A non-transitory computer readable storage medium impressed withcomputer program instructions that, when executed on a processor,implement a method comprising: maintaining a document family registrydata structure for a particular document family including documentfamily members, the document family registry data structure including:document family versions, transforms including program instructions thattransform data between document family versions, and associations of thetransforms with source document family members and target documentfamily members; and responding to requests for transforms to convert adocument from a source version to a target version by: traversing thedocument family registry data structure as a directed graph, andproviding one or more sequences of transforms determined by thetraversing.
 22. A non-transitory computer readable storage mediumimpressed with computer program instructions that, when executed on aprocessor, implement a method comprising: maintaining a document familyregistry data structure for a particular document family includingdocument family members, the document family registry data structureincluding: document family versions, and transforms including programinstructions that transform data between document family versions; andresponding to requests, which identify a first document family versionand a second document family version, by providing a transform to beexecuted remotely and that transforms the data from the first documentfamily version to the second document family version.
 23. A systemincluding one or more processors coupled to memory, the memory loadedwith computer instructions that, when executed on the processors,implement actions comprising: maintaining a document family registrydata structure for a particular document family including documentfamily members, the document family registry data structure including:document family versions, transforms including program instructions thattransform data between document family versions, and associations of thetransforms with source document family members and target documentfamily members; and responding to requests for transforms to convert adocument from a source version to a target version by: traversing thedocument family registry data structure as a directed graph, andproviding one or more sequences of transforms determined by thetraversing.
 24. A system including one or more processors coupled tomemory, the memory loaded with computer instructions that, when executedon the processors, implement actions comprising: maintaining a documentfamily registry data structure for a particular document familyincluding document family members, the document family registry datastructure including: document family versions, and transforms includingprogram instructions that transform data between document familyversions; and responding to requests, which identify a first documentfamily version and a second document family version, by providing atransform to be executed remotely and that transforms the data from thefirst document family version to the second document family version.